home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / absval.zip / ABSVAL.C next >
Text File  |  1993-04-13  |  25KB  |  691 lines
  1. /* ******************************************************************
  2.  * Function name : d_absolute(value) / f_absolute(value) /
  3.  *                 i_absolute(value)
  4.  *
  5.  *  Description  : This function returns the absolute value of
  6.  *                  the number contained in variable "value"
  7.  *
  8.  * Variables      : value  -  The number passed to the function
  9.  *                            and modified to contain the absolute
  10.  *                            value
  11.  *
  12.  * Example       : output = d_absolute(10);    returns the value 10
  13.  *                 output = f_absolute(-5);    returns the value 5
  14.  *                 output = i_absolute(45);    returns the value 45
  15.  *
  16.  * Rules         : The function must be passed a numerically defined
  17.  *                 variable. Additionally, the calling program must
  18.  *                 define the "absolute" function in a manner
  19.  *                 consistent with the version of the function called.
  20.  *                 For example if you call d_absolute than the calling
  21.  *                 program must define "d_absolute()" as a "double".
  22.  *
  23.  * Calling ex.   : For d_absolute -    double d_absolute(), output, input;
  24.  *                                     output = d_absolute(input);
  25.  *
  26.  *                 For f_absolute -    float f_absolute(), output, input;
  27.  *                                     output = f_absolute(input);
  28.  *
  29.  *                 For i_absolute -    int i_absolute(), output, input;
  30.  *                                     output = i_absolute(input);
  31.  *
  32.  */
  33. double d_absolute(value)
  34.  double value;
  35.  { if ( value < 0 ) return( 0 - value ); else return(value);
  36.  }
  37.  
  38. float f_absolute(value)
  39.  float value;
  40.  { if ( value < 0 ) return( 0 - value ); else return(value);
  41.  }
  42.  
  43. i_absolute(value)
  44.  int value;
  45.  { if ( value < 0 ) return( 0 - value ); else return(value);
  46.  }
  47.  
  48. /* ******************************************************************
  49.  * Function name : d_average(a,b) / f_average(a,b) /
  50.  *                 i_average(a,b)
  51.  *
  52.  *  Description  : This function returns the average valuσs of
  53.  *                  the numbers contained in variables "a" and "b"
  54.  *
  55.  * Variables      : a,b    -  The numbers passed to the function
  56.  *                            are averaged, this average is passed
  57.  *                            back to the calling function
  58.  *
  59.  * Example       : output = d_average(10,20);    returns the value 15
  60.  *                 output = f_average(2,4);    returns the value 3
  61.  *                 output = i_average(4,5);    returns the value 4.5
  62.  *
  63.  * Rules         : The function must be passed a numerically defined
  64.  *                 variable. Additionally, the calling program must
  65.  *                 define the "average" function in a manner
  66.  *                 consistent with the version of the function called.
  67.  *                 For example if you call d_average than the calling
  68.  *                 program must define "d_average()" as a "double".
  69.  *
  70.  * Calling ex.   : For d_average -    double d_average();
  71.  *                                    double output, input1,input2;
  72.  *                                     output = d_average(input1,input2);
  73.  *
  74.  *                 For f_average -    float f_average();
  75.  *                                    float output, input1, input2;
  76.  *                                     output = f_average(input1,input2);
  77.  *
  78.  *                 For i_average -    int i_average();
  79.  *                                    float output, input1, input2;
  80.  *                                     output = i_average(input1, input2);
  81.  *
  82.  */
  83. double d_average(value1,value2)
  84.  double value1, value2;
  85.  { return( (value1 + value2) / 2 );
  86.  }
  87.  
  88. float f_average(value1,value2)
  89.  float value1, value2;
  90.  { return( (value1 + value2) / 2 );
  91.  }
  92.  
  93. i_average(value1,value2)
  94.  int value1, value2;
  95.  { return( (value1 + value2) / 2 );
  96.  }
  97.  
  98. /* ******************************************************************
  99.  * Function name : d_cube(value) / f_cube(value) / i_cube(value)
  100.  *
  101.  *  Description  : This function returns the cube value of
  102.  *                  the number contained in variable "value"
  103.  *
  104.  * Variables      : value  -  The number passed to the function
  105.  *                            and modified to contain the cube
  106.  *                            value
  107.  *
  108.  * Example       : output = d_cube(2);    returns the value 8
  109.  *                 output = f_cube(3);    returns the value 27
  110.  *                 output = i_cube(4);    returns the value 64
  111.  *
  112.  * Rules         : The function must be passed a numerically defined
  113.  *                 variable. Additionally, the calling program must
  114.  *                 define the "cube" function in a manner
  115.  *                 consistent with the version of the function called.
  116.  *                 For example if you call d_cube than the calling
  117.  *                 program must define "d_cube()" as a "double".
  118.  *
  119.  * Calling ex.   : For d_cube -    double d_cube(), output, input;
  120.  *                                 output = d_cube(input);
  121.  *
  122.  *                 For f_cube -    float f_cube(), output, input;
  123.  *                                 output = f_cube(input);
  124.  *
  125.  *                 For i_cube -    int i_cube(), output, input;
  126.  *                                 output = i_cube(input);
  127.  *
  128.  */
  129. double d_cube(value)
  130.  double value;
  131.  { return( value * value * value );
  132.  }
  133.  
  134. float f_cube(value)
  135.  float value;
  136.  { return( value * value * value );
  137.  }
  138.  
  139. i_cube(value)
  140.  int value;
  141.  { return( value * value * value );
  142.  }
  143. /* ******************************************************************
  144.  * Function name : d_to_h(value)
  145.  *
  146.  *  Description  : This function converts the number passed
  147.  *                  from a decimal number to a hexadecimal number
  148.  *
  149.  * Variables     : dec    -  The number passed to the function 
  150.  *                           that is converted to hexadecimal
  151.  *
  152.  *                 hex    -  The variable that contains the calculated
  153.  *                           hexadecimal value passed back in the 
  154.  *                           return statement
  155.  *
  156.  *                 count  -  this variable is a counter used in the
  157.  *                           "for" loop
  158.  *                 
  159.  * Example       : output = d_to_h(20);        returns the value 24
  160.  *                 output = d_to_h(29);        returns the value 1D
  161.  *                 output = d_to_h(42);         returns the value 2A
  162.  *
  163.  * Rules         : The function must be passed a variable defined
  164.  *                 as an integer.
  165.  *
  166.  * Calling ex.   :   int output, output;
  167.  *                   output = d_to_h(input);
  168.  *
  169.  *
  170.  */
  171. d_to_h(dec)
  172.  int dec;
  173. { int hex = 0;
  174.   int count;
  175.  
  176.   for ( count=0; (dec / 16.0) != 0; count++ )
  177.    { hex = hex + ( dec % 16 ) * i_to_power(10.0, count);
  178.      dec = dec / 16;
  179.    }
  180.   return(hex);
  181. }
  182. /* ******************************************************************
  183.  * Function name : is_bin(value)
  184.  *
  185.  *  Description  : This function returns a "1" if the value passed
  186.  *                  is a binary digit, mainly a "0" or "1". If the
  187.  *                  value is not a binary digit than a "0" is returned
  188.  *
  189.  * Variables      : value  -  The number passed to the function
  190.  *                            that is tested as a binary digit
  191.  *
  192.  * Example       : output = is_bin(0);    returns the value 1
  193.  *                 output = is_bin(1);    returns the value 1
  194.  *                 output = is_bin(2);    returns the value 0
  195.  *
  196.  * Rules         : The function must be passed a variable defined
  197.  *                 as a character.
  198.  *
  199.  * Calling ex.   : For is_binary -    int output;
  200.  *                                    char input[2];
  201.  *                                     output = is_binary(input);
  202.  *
  203.  *
  204.  */
  205. is_bin(value)
  206.  char value[];
  207.  { if ( value[0] == '0' || value[0] == '1' ) return(1); else return(0);
  208.  }
  209.  
  210. /* ******************************************************************
  211.  * Function name : is_even(value)
  212.  *
  213.  *  Description  : This function returns a "1" if the value passed
  214.  *                  is a even.  If the value is not
  215.  *                  an even number than a "0" is returned
  216.  *
  217.  * Variables      : value  -  The number passed to the function
  218.  *                            that is tested as a even number
  219.  *
  220.  * Example       : output = is_even(10);    returns the value 1
  221.  *                 output = is_even(11);    returns the value 0
  222.  *                 output = is_even(12);    returns the value 1
  223.  *
  224.  * Rules         : The function must be passed a variable defined
  225.  *                 as an integer.
  226.  *
  227.  * Calling ex.   :     int output, input;
  228.  *                     output = i_is_even(input);
  229.  *
  230.  */
  231. is_even(value)
  232.  int value;
  233.  { if ( remainder(value,2) == 0 ) return(1); else return(0);
  234.  }
  235.  
  236. /* ******************************************************************
  237.  * Function name : is_hex(value)
  238.  *
  239.  *  Description  : This function returns a "1" if the value passed
  240.  *                  is a binary digit, mainly a "0" or "1". If the
  241.  *                  value is not a binary digit than a "0" is returned
  242.  *
  243.  * Variables      : value  -  The number passed to the function
  244.  *                            that is tested as a binary digit
  245.  *
  246.  * Example       : output = is_hex(0);    returns the value 1
  247.  *                 output = is_hex(1);    returns the value 1
  248.  *                 output = is_hex(2);    returns the value 0
  249.  *
  250.  * Rules         : The function must be passed a variable defined
  251.  *                 as a character.
  252.  *
  253.  * Calling ex.   : For is_hex - int output;
  254.  *                              char input[2];
  255.  *                              output = is_hexary(input);
  256.  *
  257.  *
  258.  */
  259. is_hex(value)
  260.  int value;
  261.  { if ( ( value >= '0' && value <= '9' ) ||
  262.     ( value >= 'A' && value <= 'F' ) ||
  263.     ( value <= 'a' && value <= 'f' ) )
  264.  
  265.         return(1);
  266.  
  267.    else return(0);
  268.  }
  269.  
  270. /* ******************************************************************
  271.  * Function name : is_octal(value)
  272.  *
  273.  *  Description  : This function returns a "1" if the value passed
  274.  *                  is an octal digit, mainly a 0 thru 7.  If the
  275.  *                  value is not an octal digit than a "0" is returned
  276.  *
  277.  * Variables      : value  -  The number passed to the function
  278.  *                            that is tested as an octal digit
  279.  *
  280.  * Example       : output = is_octal(0);    returns the value 1
  281.  *                 output = is_octal(6);    returns the value 1
  282.  *                 output = is_octal(9);    returns the value 0
  283.  *
  284.  * Rules         : The function must be passed a variable defined
  285.  *                 as a character.
  286.  *
  287.  * Calling ex.   : For is_octal - int output;
  288.  *                                char input[2];
  289.  *                                output = is_octal(input);
  290.  *
  291.  *
  292.  */
  293. is_octal(value)
  294.  int value;
  295.  { if ( value >= '0' && value <= '7' ) return(1); else return(0);
  296.  }
  297.  
  298. /* ******************************************************************
  299.  * Function name : is_odd(value)
  300.  *
  301.  *  Description  : This function returns a "1" if the value passed
  302.  *                  is a odd.  If the value is not
  303.  *                  an odd number than a "0" is returned
  304.  *
  305.  * Variables      : value  -  The number passed to the function
  306.  *                            that is tested as a odd number
  307.  *
  308.  * Example       : output = is_odd(10);    returns the value 1
  309.  *                 output = is_odd(11);    returns the value 0
  310.  *                 output = is_odd(12);    returns the value 1
  311.  *
  312.  * Rules         : The function must be passed a variable defined
  313.  *                 as an integer.
  314.  *
  315.  * Calling ex.   :     int output, input;
  316.  *                     output = i_is_odd(input);
  317.  *
  318.  */
  319. is_odd(value)
  320.  int value;
  321.  { if ( remainder(value,2) != 0 ) return(1); else return(0);
  322.  }
  323. /* ******************************************************************
  324.  * Function name : d_max(value1, value2) / f_max(value1, value2) /
  325.  *                 i_max(value1, value2)
  326.  *
  327.  *  Description  : This function returns the number with the maximum
  328.  *                  value.
  329.  *
  330.  * Variables      : value1 -  The numbers passed to the function
  331.  *                  value2    and compared to assess the maximum
  332.  *                            value
  333.  *
  334.  * Example       : output = d_max(10);    returns the value 10
  335.  *                 output = f_max(-5);    returns the value 5
  336.  *                 output = i_max(45);    returns the value 45
  337.  *
  338.  * Rules         : The function must be passed a numerically defined
  339.  *                 variable. Additionally, the calling program must
  340.  *                 define the "max" function in a manner
  341.  *                 consistent with the version of the function called.
  342.  *                 For example if you call d_max than the calling
  343.  *                 program must define "d_max()" as a "double".
  344.  *
  345.  * Calling ex.   : For d_max -    double d_max(), output, input;
  346.  *                                output = d_max(input);
  347.  *
  348.  *                 For f_max -    float f_max(), output, input;
  349.  *                                output = f_max(input);
  350.  *
  351.  *                 For i_max -    int i_max(), output, input;
  352.  *                                output = i_max(input);
  353.  *
  354.  */
  355. double d_max(value1, value2)
  356.  double value1, value2;
  357.  { if ( value1 > value2 ) return( value1 ); else return(value2);
  358.  }
  359.  
  360. float f_max(value1, value2)
  361.  float value1, value2;
  362.  { if ( value1 > value2 ) return( value1 ); else return(value2);
  363.  }
  364.  
  365. i_max(value1, value2)
  366.  int value1, value2;
  367.  { if ( value1 > value2 ) return( value1 ); else return(value2);
  368.  }
  369.  
  370. /* ******************************************************************
  371.  * Function name : d_min(value1, value2) / f_min(value1, value2) /
  372.  *                 i_min(value1, value2)
  373.  *
  374.  *  Description  : This function return≤ thσ number with the minimum
  375.  *                  value.
  376.  *
  377.  * Variables      : value1 -  The numbers passed to the function
  378.  *                  value2    and compared to assess the minimum
  379.  *                            value
  380.  *
  381.  * Example       : output = d_min(10);    returns the value 10
  382.  *                 output = f_min(-5);    returns the value 5
  383.  *                 output = i_min(45);    returns the value 45
  384.  *
  385.  * Rules         : The function must be passed a numerically defined
  386.  *                 variable. Additionally, the calling program must
  387.  *                 define the "min" function in a manner
  388.  *                 consistent with the version of the function called.
  389.  *                 For example if you call d_min than the calling
  390.  *                 program must define "d_min()" as a "double".
  391.  *
  392.  * Calling ex.   : For d_min -    double d_min(), output, input;
  393.  *                                output = d_min(input);
  394.  *
  395.  *                 For f_min -    float f_min(), output, input;
  396.  *                                output = f_min(input);
  397.  *
  398.  *                 For i_min -    int i_min(), output, input;
  399.  *                                output = i_min(input);
  400.  *
  401.  */
  402. double d_min(value1, value2)
  403.  double value1, value2;
  404.  { if ( value1 < value2 ) return( value1 ); else return(value2);
  405.  }
  406.  
  407. float f_min(value1, value2)
  408.  float value1, value2;
  409.  { if ( value1 < value2 ) return( value1 ); else return(value2);
  410.  }
  411.  
  412. i_min(value1, value2)
  413.  int value1, value2;
  414.  { if ( value1 < value2 ) return( value1 ); else return(value2);
  415.  }
  416.  
  417. /* ******************************************************************
  418.  * Function name : d_percent(value1, value2) / f_percent(value1, value2) /
  419.  *                 i_percent(value1, value2)
  420.  *
  421.  *  Description  : This function return≤ thσ number with the minimum
  422.  *                  value.
  423.  *
  424.  * Variables      : value1 -  The numbers passed to the function
  425.  *                  value2    and compared to assess the minimum
  426.  *                            value
  427.  *
  428.  * Example       : output = d_percent(10);    returns the value 10
  429.  *                 output = f_percent(-5);    returns the value 5
  430.  *                 output = i_percent(45);    returns the value 45
  431.  *
  432.  * Rules         : The function must be passed a numerically defined
  433.  *                 variable. Additionally, the calling program must
  434.  *                 define the "min" function in a manner
  435.  *                 consistent with the version of the function called.
  436.  *                 For example if you call d_percent than the calling
  437.  *                 program must define "d_percent()" as a "double".
  438.  *
  439.  * Calling ex.   : For d_percent -    double d_percent(), output, input;
  440.  *                                output = d_percent(input);
  441.  *
  442.  *                 For f_percent -    float f_percent(), output, input;
  443.  *                                output = f_percent(input);
  444.  *
  445.  *                 For i_percent -    int i_percent(), output, input;
  446.  *                                output = i_percent(input);
  447.  *
  448.  */
  449. double d_percent(value1, value2)
  450.  double value1, value2;
  451.  { return (value1 / value2 );
  452.  }
  453.  
  454. float f_percent(value1, value2)
  455.  float value1, value2;
  456.  { return (value1 / value2 );
  457.  }
  458.  
  459. i_percent(value1, value2)
  460.  int value1, value2;
  461.  { return (value1 / value2 );
  462.  }
  463.  
  464. /* ******************************************************************
  465.  * Function name : d_power(value1, value2) / f_power(value1, value2) /
  466.  *                 i_power(value1, value2)
  467.  *
  468.  *  Description  : This function returns the number with the minimum
  469.  *                  value.
  470.  *
  471.  * Variables      : value1 -  The numbers passed to the function
  472.  *                  value2    and compared to assess the minimum
  473.  *                            value
  474.  *
  475.  * Example       : output = d_power(10);    returns the value 10
  476.  *                 output = f_power(-5);    returns the value 5
  477.  *                 output = i_power(45);    returns the value 45
  478.  *
  479.  * Rules         : The function must be passed a numerically defined
  480.  *                 variable. Additionally, the calling program must
  481.  *                 define the "min" function in a manner
  482.  *                 consistent with the version of the function called.
  483.  *                 For example if you call d_power than the calling
  484.  *                 program must define "d_power()" as a "double".
  485.  *
  486.  * Calling ex.   : For d_power -    double d_power(), output, input;
  487.  *                                output = d_power(input);
  488.  *
  489.  *                 For f_power -    float f_power(), output, input;
  490.  *                                output = f_power(input);
  491.  *
  492.  *                 For i_power -    int i_power(), output, input;
  493.  *                                output = i_power(input);
  494.  *
  495.  */
  496. double d_to_power(value,n)
  497.  double value,n;
  498. { int count;
  499.   double result;
  500.   result = 1;
  501.   for ( count=1; count <= n; count++ )
  502.    result = result * value;
  503.  
  504.   return(result);
  505. }
  506.  
  507. float f_to_power(value,n)
  508.  float value,n;
  509. { int count;
  510.   float result;
  511.   result = 1;
  512.   for ( count=1; count <= n; count++ )
  513.    result = result * value;
  514.  
  515.   return(result);
  516. }
  517.  
  518. i_to_power(value,n)
  519. int value,n;
  520. { int count, result;
  521.   result = 1;
  522.   for ( count=1; count <= n; count++ )
  523.    result = result * value;
  524.  
  525.   return(result);
  526. }
  527. /* ******************************************************************
  528.  * Function name : is_remainder(value1, value2 )
  529.  *
  530.  *  Description  : This function returns a "1" if the value passed
  531.  *                  is a remainder.  If the value is not
  532.  *                  an remainder number than a "0" is returned
  533.  *
  534.  * Variables      : value  -  The number passed to the function
  535.  *                            that is tested as a remainder number
  536.  *
  537.  * Example       : output = is_remainder(10);    returns the value 1
  538.  *                 output = is_remainder(11);    returns the value 0
  539.  *                 output = is_remainder(12);    returns the value 1
  540.  *
  541.  * Rules         : The function must be passed a variable defined
  542.  *                 as an integer.
  543.  *
  544.  * Calling ex.   :     int output, input;
  545.  *                     output = i_is_remainder(input);
  546.  *
  547.  */
  548.  
  549. remainder(value1, value2)
  550.  int value1, value2;
  551. { int remaind;
  552.   remaind = value1 % value2;
  553.   return (remaind);
  554. }
  555.  
  556. /* ******************************************************************
  557.  * Function name : d_round(value) / f_round(value)
  558.  *
  559.  *  Description  : This function returns the round value of
  560.  *                  the number contained in variable "value"
  561.  *
  562.  * Variables      : value  -  The number passed to the function
  563.  *                            and modified to contain the round
  564.  *                            value
  565.  *
  566.  * Example       : output = d_round(2);    returns the value 8
  567.  *                 output = f_round(3);    returns the value 27
  568.  *
  569.  * Rules         : The function must be passed a numerically defined
  570.  *                 variable. Additionally, the calling program must
  571.  *                 define the "round" function in a manner
  572.  *                 consistent with the version of the function called.
  573.  *                 For example if you call d_round than the calling
  574.  *                 program must define "d_round()" as a "double".
  575.  *
  576.  * Calling ex.   : For d_round -    double d_round(), output, input;
  577.  *                                 output = d_round(input);
  578.  *
  579.  *                 For f_round -    float f_round(), output, input;
  580.  *                                 output = f_round(input);
  581.  *
  582.  */
  583. double d_round(value)
  584.  double value;
  585.  { int temp1;
  586.    double temp2;
  587.    temp1 = value + .5;
  588.    temp2 = temp1;
  589.    return( temp2);
  590.  }
  591.  
  592. float f_round(value)
  593.  float value;
  594.  { int temp1;
  595.    float temp2;
  596.    temp1 = value + .5;
  597.    temp2 = temp1;
  598.    return( temp2);
  599.  }
  600.  
  601. /* ******************************************************************
  602.  * Function name : d_sqare(value) / f_sqare(value) / i_sqare(value)
  603.  *
  604.  *  Description  : This function returns the sqare value of
  605.  *                  the number contained in variable "value"
  606.  *
  607.  * Variables      : value  -  The number passed to the function
  608.  *                            and modified to contain the sqare
  609.  *                            value
  610.  *
  611.  * Example       : output = d_sqare(2);    returns the value 8
  612.  *                 output = f_sqare(3);    returns the value 27
  613.  *                 output = i_sqare(4);    returns the value 64
  614.  *
  615.  * Rules         : The function must be passed a numerically defined
  616.  *                 variable. Additionally, the calling program must
  617.  *                 define the "sqare" function in a manner
  618.  *                 consistent with the version of the function called.
  619.  *                 For example if you call d_sqare than the calling
  620.  *                 program must define "d_sqare()" as a "double".
  621.  *
  622.  * Calling ex.   : For d_sqare -    double d_sqare(), output, input;
  623.  *                                 output = d_sqare(input);
  624.  *
  625.  *                 For f_sqare -    float f_sqare(), output, input;
  626.  *                                 output = f_sqare(input);
  627.  *
  628.  *                 For i_sqare -    int i_sqare(), output, input;
  629.  *                                 output = i_sqare(input);
  630.  *
  631.  */
  632. double d_sqare(value)
  633.  double value;
  634.  { return( value * value );
  635.  }
  636.  
  637. float f_sqare(value)
  638.  float value;
  639.  { return( value * value );
  640.  }
  641.  
  642. i_sqare(value)
  643.  int value;
  644.  { return( value * value );
  645.  }
  646.  
  647. /* ******************************************************************
  648.  * Function name : d_truncate(value) / f_truncate(value)
  649.  *
  650.  *  Description  : This function returns the truncate valuσ of
  651.  *                  the number contained in variable "value"
  652.  *
  653.  * Variables      : value  -  The number passed to the function
  654.  *                            and modified to contain the truncate
  655.  *                            value
  656.  *
  657.  * Example       : output = d_truncate(2);    returns the value 8
  658.  *                 output = f_truncate(3);    returns the value 27
  659.  *
  660.  * Rules         : The function must be passed a numerically defined
  661.  *                 variable. Additionally, the calling program must
  662.  *                 define the "truncate" function in a manner
  663.  *                 consistent with the version of the function called.
  664.  *                 For example if you call d_truncate than the calling
  665.  *                 program must define "d_truncate()" as a "double".
  666.  *
  667.  * Calling ex.   : For d_truncate -    double d_truncate(), output, input;
  668.  *                                 output = d_truncate(input);
  669.  *
  670.  *                 For f_truncate -    float f_truncate(), output, input;
  671.  *                                 output = f_truncate(input);
  672.  *
  673.  */
  674. double d_truncate(value)
  675.  double value;
  676.  { int temp1;
  677.    double temp2;
  678.    temp1 = value;
  679.    temp2 = temp1;
  680.    return( temp2);
  681.  }
  682.  
  683. float f_truncate(value)
  684.  float value;
  685.  { int temp1;
  686.    float temp2;
  687.    temp1 = value;
  688.    temp2 = temp1;
  689.    return( temp2);
  690.  }
  691.